/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pos.controller;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import pos.client.dac.dao.PianoDAO;
import pos.client.dac.dao.PianoDAOAsync;
import pos.client.dac.dao.TipoLinkcomposto_daDAO;
import pos.client.dac.dao.TipoLinkcomposto_daDAOAsync;
import pos.domain.*;
import pos.gui.Index;
import pos.gui.PianiView;
import pos.server.dac.exceptions.EccezioneCRUD;

/**
 *
 * @author F
 */
public class PianiController {

    private static TipoLinkcomposto_daDAOAsync linkCompostoDaService = (TipoLinkcomposto_daDAOAsync) GWT.create(TipoLinkcomposto_daDAO.class);
    private static PianoDAOAsync pianoService = (PianoDAOAsync) GWT.create(PianoDAO.class);
    
    public static Collection<Corso> getAllCorsiNotInPiani(Utente u, Piano p) {
        // tutti i corsi del utente U che non fanno parte del piano P 
        Collection<Corso> corsi = new HashSet<Corso>();

        HashSet<TipoLinkDeveSostenere> ins_link = (HashSet<TipoLinkDeveSostenere>) u.getLinkDeveSostenere();

        HashSet<TipoLinkcomposto_da> link_corsi_piano = (HashSet<TipoLinkcomposto_da>) p.getCorsi();
        HashSet<Corso> corsi_piano = new HashSet<Corso>();

        Iterator<TipoLinkcomposto_da> it2 = link_corsi_piano.iterator();
        while (it2.hasNext()) {
            corsi_piano.add(it2.next().getCorso());
        }

        Iterator<TipoLinkDeveSostenere> it = ins_link.iterator();
        while (it.hasNext()) {
            Corso c = it.next().getCorso();
            if (!corsi_piano.contains(c)) {
                corsi.add(c);
            }
        }

        return corsi;
    }

    public static void aggiungiCorsoInPiano(Corso c, Piano p, int a, int s) throws EccezionePrecondizioni, EccezioneCRUD {

        //relazione+link 
        AsyncCallback<Void> callback = new AsyncCallback<Void>() {

            @Override
            public void onFailure(Throwable caught) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void onSuccess(Void result) {;
            }
        };

        TipoLinkcomposto_da link = new TipoLinkcomposto_da(p, c, a, s);
        p.inserisciCorso(link);
        linkCompostoDaService.inserisciDatisuDb(link, callback);

    }

    public static void eliminaCorsoDaPiano(Piano p, Corso c, Utente u) throws EccezionePrecondizioni, EccezioneCRUD {

        AsyncCallback<Void> callback = new AsyncCallback<Void>() {

            @Override
            public void onFailure(Throwable caught) {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            @Override
            public void onSuccess(Void result) {;
            }
        };

        TipoLinkcomposto_da link = new TipoLinkcomposto_da(p, c, 0, 0);
        p.eliminaCorso(link);
        linkCompostoDaService.eliminaDatisuDb(link, u, callback);
    }

    public static void aggiungiPiano(String text) {
        Piano nuovoPiano = new Piano(text);
        try {
            Index.getUtente().inserisciLinkCrea(new TipoLinkU_P(Index.getUtente(), nuovoPiano));
            
            pianoService.inserisciDatisuDB(nuovoPiano, Index.getUtente(), new AsyncCallback<Piano>() {

                @Override
                public void onFailure(Throwable caught) {
                    System.out.println(caught.getMessage());
                }

                @Override
                public void onSuccess(Piano result) {
                    PianiView.getModel().add(result);
                    PianiView.refreshPiani();
                }
            });
        } catch (EccezionePrecondizioni ex) {
            Logger.getLogger(PianiController.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public static void eliminaPiano(final Piano p) {
        try {
            Index.getUtente().eliminaLinkCrea(new TipoLinkU_P(Index.getUtente(), p));
            pianoService.cancellaDatidaDB(p, new AsyncCallback<Void>() {

                @Override
                public void onFailure(Throwable caught) {
                    throw new UnsupportedOperationException("Not supported yet.");
                }

                @Override
                public void onSuccess(Void result) {
                    PianiView.getModel().remove(p);
                    PianiView.refreshPiani();
                }
            });
        } catch (EccezionePrecondizioni ex) {
            Logger.getLogger(PianiController.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}
